Interface-Oriented Programming

The predominant design of object-oriented programming languages today provides insufficient support for interface abstraction and implementation inheritance, a limitation that forces software components to be unnecessarily biased towards particular implementations of other components. This scatters implementation bias across a system and impairs its ability to evolve. In this paper we trace the origin of implementation bias to concrete instantiation dependencies, points in a program text where objects are explicitly or implicitly instantiated in terms of class name references. We then propose interface-oriented programming as a solution, a new approach to language design and software engineering that can eliminate implementation bias by strictly separating interfaces from implementations and decoupling the inheritance mechanism from the implementation binding mechanism. In interface-oriented programming, all program dependencies are expressed through abstract interfaces, and interface clients are bound with implementations using non-deterministic instantiation, a mechanism that automatically selects an implementation of an interface from among a set of alternatives. Partial and incremental implementation of abstract interfaces in terms of other assumed interfaces is allowed, providing a form of mixin-inheritance that separates interface inheritance from implementation inheritance, but with support for constructors, and without the need for explicit composition. Composition of these separately compiled, partial implementations is handled by a new form of program linking called representaton inference. The representation inference mechanism uses type constraints and method constraints to infer compatible compositions of available partial representations for an interface.